// 公告详情页面
const { getCurrentRole, getCurrentUser } = require('../../../utils/auth')
const { getNoticeDetail, updateReadDuration, deleteNotice: deleteNoticeAPI } = require('../../../api/notice')
const smartLoadingManager = require('../../../utils/smartLoadingManager')

Page({
  data: {
    notice: null,
    loading: true,
    isAdmin: false, // 是否为管理员
    currentUser: null, // 当前用户信息
    readStartTime: null, // 阅读开始时间
    readTimer: null, // 阅读计时器
    currentNoticeId: null, // 当前公告ID
    isPublisher: false // 是否为发布者
  },
  // 全局加载状态
  globalLoading: false,
  globalLoadingText: '村务信息加载中...',

  // 显示全局加载
  showGlobalLoading(text = '村务信息加载中...') {
    const app = getApp()
    app.showGlobalLoading({
      loadingText: text
    })
  },

  // 隐藏全局加载
  hideGlobalLoading() {
    const app = getApp()
    app.hideGlobalLoading()
  },

  // 更新全局加载状态
  updateGlobalLoading(data) {
    this.setData({
      globalLoading: data.globalLoading,
      globalLoadingText: data.globalLoadingText || this.data.globalLoadingText
    })
  },

  onLoad(options) {
    // 显示页面加载效果
    smartLoadingManager.onPageEnter('pages/village/notice-detail/index', {
      loadingText: '村务信息加载中...'
    })
    this.checkLoginStatus()
    const { id } = options
    if (id) {
      this.loadNoticeDetail(id)
    } else {
      wx.showToast({ title: '公告ID不存在', icon: 'none' })
      setTimeout(() => wx.navigateBack(), 1500)
    }
  },

  onShow() {
    this.checkLoginStatus()
    // 页面显示时开始计时（仅对非发布者且有阅读开始时间）
    if (this.data.readStartTime && this.data.currentNoticeId && !this.data.isPublisher) {
      console.log('页面显示，启动阅读计时器');
      this.startReadTimer();
    } else if (this.data.isPublisher) {
      console.log('发布者本人，不启动阅读计时器');
    } else {
      console.log('阅读计时条件不满足:', {
        readStartTime: !!this.data.readStartTime,
        currentNoticeId: !!this.data.currentNoticeId,
        isPublisher: this.data.isPublisher
      });
    }
  },

  onHide() {
    // 页面隐藏时停止计时并更新阅读时长（仅对非发布者）
    if (!this.data.isPublisher) {
      console.log('页面隐藏，停止阅读计时');
      this.stopReadTimer();
    } else {
      console.log('发布者本人，跳过阅读计时停止');
    }
  },

  onUnload() {
    // 页面卸载时停止计时并更新阅读时长（仅对非发布者）
    if (!this.data.isPublisher) {
      console.log('页面卸载，停止阅读计时');
      this.stopReadTimer();
    } else {
      console.log('发布者本人，跳过阅读计时停止');
    }
  },

  // 检查登录状态
  checkLoginStatus() {
    try {
      const role = getCurrentRole()
      if (!role) {
        wx.redirectTo({ url: '/pages/auth/login/index' })
        return
      }
      
      // 检查是否为管理员
      const isAdmin = role === 'admin'
      console.log('当前用户角色:', role, '是否为管理员:', isAdmin)
      this.setData({ 
        isAdmin: isAdmin,
        currentUser: {
          role: role,
          // 这里可以添加更多用户信息
        }
      })
    } catch (e) {
      console.error('获取角色失败:', e)
      wx.redirectTo({ url: '/pages/auth/login/index' })
    }
  },

  // 加载公告详情
  async loadNoticeDetail(id) {
    try {
      console.log('加载公告详情，ID:', id);
      
      // 获取当前用户ID
      const currentUser = getCurrentUser();
      const userId = currentUser ? currentUser.userId : null;
      
      // 获取设备信息
      const deviceInfo = this.getDeviceInfo();
      console.log('设备信息:', deviceInfo);
      
      const response = await getNoticeDetail(id, {
        userId,
        deviceType: deviceInfo.deviceType,
        userAgent: deviceInfo.userAgent,
        ipAddress: deviceInfo.ipAddress
      });
      
      if (response.success) {
        const noticeData = response.data.notice;
        
        // 检查当前用户是否为发布者
        const isPublisher = currentUser && noticeData.publisherId === parseInt(currentUser.userId);
        
        // 格式化公告数据
        const formattedNotice = {
          id: noticeData.id,
          title: noticeData.title,
          content: noticeData.content,
          type: noticeData.type,
          typeText: this.getTypeText(noticeData.type),
          status: noticeData.status,
          statusText: noticeData.statusText,
          publishTime: noticeData.publishTime ? this.formatTime(new Date(noticeData.publishTime)) : '',
          publishDept: noticeData.dept,
          readCount: noticeData.readCount || 0,
          isUrgent: noticeData.isUrgent || false,
          publisherName: noticeData.publisherName,
          createTime: this.formatTime(new Date(noticeData.createTime)),
          updateTime: this.formatTime(new Date(noticeData.updateTime))
        };
        
        this.setData({ 
          notice: formattedNotice,
          loading: false,
          isPublisher: isPublisher,
          currentNoticeId: id
        });
        
        // 只有非发布者才记录阅读开始时间
        if (!isPublisher) {
          this.setData({
            readStartTime: Date.now()
          });
          console.log('非发布者，开始阅读计时');
        } else {
          console.log('发布者本人，跳过阅读计时');
        }
        
        // 数据加载完成，通知智能加载管理器
        smartLoadingManager.onPageDataLoaded('pages/village/notice-detail/index');
        console.log('公告详情加载成功:', formattedNotice.title);
        console.log('是否为发布者:', isPublisher);
      } else {
        smartLoadingManager.forceHidePageLoading('pages/village/notice-detail/index');
        wx.showToast({ 
          title: response.message || '获取公告详情失败', 
          icon: 'none' 
        });
        setTimeout(() => wx.navigateBack(), 1500);
      }
    } catch (error) {
      console.error('加载公告详情失败:', error);
      smartLoadingManager.forceHidePageLoading('pages/village/notice-detail/index');
      wx.showToast({ 
        title: '网络错误，请重试', 
        icon: 'none' 
      });
      setTimeout(() => wx.navigateBack(), 1500);
    }
  },

  // 获取类型文本
  getTypeText(type) {
    const typeMap = {
      'notice': '通知公告',
      'finance': '财务公开',
      'project': '项目建设',
      'policy': '政策文件',
      'activity': '活动通知',
      'urgent': '紧急通知'
    };
    return typeMap[type] || '通知公告';
  },

  // 格式化时间
  formatTime(date) {
    const year = date.getFullYear()
    const month = date.getMonth() + 1
    const day = date.getDate()
    const hour = date.getHours()
    const minute = date.getMinutes()
    
    return `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')} ${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`
  },

  // 分享公告
  onShare() {
    const { notice } = this.data
    if (notice) {
      wx.showShareMenu({
        withShareTicket: true,
        menus: ['shareAppMessage', 'shareTimeline']
      })
    }
  },

  // 显示其他操作面板（使用微信内置ActionSheet）
  onShowOtherActions() {
    const { notice } = this.data
    if (!notice) return

    // 根据公告状态动态构建选项列表
    let itemList = []
    let actions = []

    if (notice.status === 'published') {
      // 已发布公告的操作选项
      itemList = ['编辑公告', '撤回公告']
      actions = ['edit', 'unpublish']
    } else if (notice.status === 'draft') {
      // 草稿公告的操作选项
      itemList = ['编辑公告', '发布公告']
      actions = ['edit', 'publish']
    } else {
      // 默认选项
      itemList = ['编辑公告']
      actions = ['edit']
    }

    wx.showActionSheet({
      itemList: itemList,
      success: (res) => {
        const action = actions[res.tapIndex]
        // 所有操作都跳转到管理页面
        this.navigateToNoticeManage(action)
      },
      fail: (err) => {
        // 用户取消操作或操作失败
        console.log('操作面板取消或失败:', err)
      }
    })
  },

  // 跳转到公告管理页面
  navigateToNoticeManage(action) {
    const { notice } = this.data
    if (!notice) return

    // 构建跳转URL，传递action和id参数
    const url = `/pages/admin/notices/index?action=${action}&id=${notice.id}`
    
    wx.navigateTo({
      url: url,
      success: () => {
        console.log(`跳转到公告管理页面成功，操作类型: ${action}`)
      },
      fail: (err) => {
        console.error('跳转失败:', err)
        wx.showToast({ title: '跳转失败', icon: 'none' })
      }
    })
  },

  // 返回
  onBack() {
    wx.navigateBack()
  },


  // 删除公告
  onDeleteNotice() {
    const { notice } = this.data
    if (!notice) return
    
    wx.showModal({
      title: '删除公告',
      content: `确定要删除"${notice.title}"吗？此操作不可恢复。`,
      confirmText: '删除',
      cancelText: '取消',
      confirmColor: '#ef4444',
      success: (res) => {
        if (res.confirm) {
          this.deleteNotice(notice.id)
        }
      }
    })
  },

  // 执行删除公告
  async deleteNotice(id) {
    if (!id) {
      wx.showToast({
        title: '公告ID不存在',
        icon: 'none'
      })
      return
    }

    // 显示加载提示
    wx.showLoading({
      title: '删除中...',
      mask: true
    })

    try {
      const response = await deleteNoticeAPI(id)
      
      wx.hideLoading()

      if (response.success) {
        wx.showToast({
          title: '删除成功！',
          icon: 'success',
          duration: 1500
        })
        
        // 延迟返回上一页
        setTimeout(() => {
          wx.navigateBack()
        }, 1500)
      } else {
        wx.showToast({
          title: response.message || '删除失败',
          icon: 'none',
          duration: 2000
        })
      }
    } catch (error) {
      console.error('删除公告失败:', error)
      wx.hideLoading()
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 获取设备信息
  getDeviceInfo() {
    try {
      const systemInfo = wx.getSystemInfoSync();
      console.log('系统信息:', systemInfo);
      
      const deviceInfo = {
        deviceType: this.getDeviceType(systemInfo),
        userAgent: `${systemInfo.brand} ${systemInfo.model} ${systemInfo.system} ${systemInfo.version}`,
        ipAddress: null // 小程序无法获取真实IP，可以后续通过其他方式获取
      };
      
      console.log('生成的设备信息:', deviceInfo);
      return deviceInfo;
    } catch (error) {
      console.error('获取设备信息失败:', error);
      return {
        deviceType: 'unknown',
        userAgent: 'unknown',
        ipAddress: null
      };
    }
  },

  // 获取设备类型
  getDeviceType(systemInfo) {
    const platform = systemInfo.platform.toLowerCase();
    if (platform.includes('android')) {
      return 'mobile';
    } else if (platform.includes('ios')) {
      return 'mobile';
    } else if (platform.includes('windows') || platform.includes('mac')) {
      return 'desktop';
    } else {
      return 'unknown';
    }
  },

  // 开始阅读计时
  startReadTimer() {
    if (this.data.readTimer) {
      clearInterval(this.data.readTimer);
    }
    
    console.log('启动阅读计时器，开始时间:', this.data.readStartTime);
    
    const timer = setInterval(() => {
      this.updateReadDuration();
    }, 3000); // 每3秒更新一次阅读时长
    
    this.setData({ readTimer: timer });
  },

  // 停止阅读计时
  stopReadTimer() {
    if (this.data.readTimer) {
      clearInterval(this.data.readTimer);
      this.setData({ readTimer: null });
    }
    
    // 最终更新阅读时长
    this.updateReadDuration(true);
  },

  // 更新阅读时长
  async updateReadDuration(isFinal = false) {
    try {
      const { readStartTime, currentNoticeId, isPublisher } = this.data;
      const currentUser = getCurrentUser();
      
      // 如果是发布者，不进行阅读时长统计
      if (isPublisher) {
        console.log('发布者本人，跳过阅读时长统计');
        return;
      }
      
      if (!readStartTime || !currentNoticeId || !currentUser) {
        console.log('阅读时长更新条件不满足:', { 
          readStartTime: !!readStartTime, 
          currentNoticeId: !!currentNoticeId, 
          currentUser: !!currentUser 
        });
        return;
      }
      
      const readDuration = Math.floor((Date.now() - readStartTime) / 1000); // 转换为秒
      
      if (readDuration >= 1) { // 至少1秒才更新
        console.log('更新阅读时长:', { 
          noticeId: currentNoticeId, 
          userId: currentUser.userId, 
          duration: readDuration,
          isFinal: isFinal
        });
        
        const response = await updateReadDuration(currentNoticeId, {
          user_id: currentUser.userId,
          read_duration: readDuration
        });
        
        if (response.success) {
          console.log('阅读时长更新成功:', response.data);
        } else {
          console.log('阅读时长更新失败:', response.message);
        }
      } else {
        console.log('阅读时长不足1秒，跳过更新');
      }
      
      // 只有在最终更新时才清除开始时间
      if (isFinal) {
        console.log('最终更新，清除阅读状态');
        this.setData({ readStartTime: null, currentNoticeId: null });
      }
    } catch (error) {
      console.error('更新阅读时长失败:', error);
    }
  }
})